const { FFMPEG_V2_PATH } = require("./ffmpeg");
const fs = require('fs');
const path = require('path');
const { loadConfig } = require("./config");
const config = loadConfig();
const transitionsPath = config.transitionsPath;
/**
 * 预处理视频文件，添加tpad效果以保持时长
 * @param {string} listFilePath - 包含视频文件路径的列表文件
 * @returns {void}
 */
function preprocessVideosWithTpad(listFilePath) {
  // 读取列表文件
  const listContent = fs.readFileSync(listFilePath, 'utf-8');
  const lines = listContent.split("\n").filter(line => line.trim() !== "");
  
  // 获取视频时长信息
  const { execSync } = require('child_process');
  const concatFileDir = path.dirname(listFilePath);
  
  console.log(`总共 ${Math.ceil(lines.length/2)} 个视频`);
  
  // 处理每个视频文件（除了最后一个）
  for (let i = 0; i < lines.length; i += 2) {
    console.log(`循环 i=${i}`);
    // 检查是否是有效的文件行
    if (i >= lines.length) {
      console.log(`索引超出范围 i=${i}`);
      continue;
    }
    
    // 修复：更好地处理BOM字符和行首空白
    const fileLine = lines[i].trim();
    // 移除可能的BOM字符
    const cleanFileLine = fileLine.replace(/^\uFEFF/, '');
    console.log(`原始行: "${lines[i]}"`);
    console.log(`清理后: "${cleanFileLine}"`);
    
    if (!cleanFileLine.startsWith("file ")) {
      console.log(`行不以"file "开头`);
      continue;
    }
    
    const match = cleanFileLine.match(/file '(.+)'$/);
    if (!match) {
      console.error(`无法解析文件行: ${cleanFileLine}`);
      continue;
    }
    
    const filePath = match[1];
    const fullPath = path.join(concatFileDir, filePath);
    const outputPath = path.join(concatFileDir, filePath.replace(/\.mp4$/, `_tpad.mp4`));
    
    // 获取当前视频的时长
    const durationLine = lines[i + 1];
    if (!durationLine || !durationLine.startsWith("duration ")) {
      throw new Error(`Missing duration for file ${filePath}`);
    }
    
    const duration = parseFloat(durationLine.match(/duration ([\d.]+)/)[1]);
    if (isNaN(duration) || duration <= 0) {
      throw new Error(`Invalid duration for file ${filePath}: ${duration}`);
    }
    
    console.log(`检查视频 ${i/2 + 1}: i=${i}, lines.length=${lines.length}`);
    console.log(`  当前文件: ${filePath}`);
    console.log(`  下一个文件索引: ${i + 2}`);
    
    // 只有当存在下一个视频时才添加tpad效果
    // 修复：正确处理所有视频，除了最后一个
    if (i + 2 < lines.length) {
      // 检查下一行是否是文件行
      const nextFileLine = lines[i + 2].trim().replace(/^\uFEFF/, '');
      if (nextFileLine.startsWith("file ")) {
        const nextFileMatch = nextFileLine.match(/file '(.+)'$/);
        if (nextFileMatch) {
          const nextDurationLine = lines[i + 3]; // 下一个视频的 duration 行
          
          if (nextDurationLine && nextDurationLine.startsWith("duration ")) {
            const nextDuration = parseFloat(nextDurationLine.match(/duration ([\d.]+)/)[1]);
            if (!isNaN(nextDuration) && nextDuration > 0) {
              // 转场时长取前后视频时长的较小值，且不超过1秒
              const transDur = Math.min(1, Math.min(duration, nextDuration));
              
              // 构建FFmpeg命令，添加tpad效果
              const command = `${FFMPEG_V2_PATH} -y -i "${fullPath}" -vf "tpad=stop_mode=clone:stop_duration=${transDur}" -c:v h264_mf -quality 80 -pix_fmt yuv420p -c:a copy "${outputPath}"`;
              
              console.log(`处理视频 ${i/2 + 1}/${Math.ceil(lines.length/2)}: ${fullPath}`);
              console.log(`命令: ${command}`);
              
              try {
                execSync(command, { stdio: 'inherit' });
                console.log(`完成处理: ${outputPath}`);
                
                // 更新列表文件中的路径
                lines[i] = `file '${filePath.replace(/\.mp4$/, `_tpad.mp4`)}'`;
              } catch (error) {
                console.error(`处理视频失败: ${fullPath}`, error);
                throw error;
              }
            }
          }
        }
      }
    } else {
      console.log(`  跳过处理（没有下一个视频）`);
    }
  }
  
  // 将更新后的路径写回列表文件
  fs.writeFileSync(listFilePath, lines.join('\n') + '\n', 'utf-8');
  console.log(`列表文件已更新: ${listFilePath}`);
}
/**
 * 生成多个视频之间的3D翻页转场效果命令
 * @param {string[]} videoPaths - 视频文件路径数组
 * @param {Object} options - 配置选项
 * @param {number} options.transitionDuration - 翻页转场时长（秒），默认为1秒
 * @param {number} options.totalDuration - 总时长（秒），如果指定则覆盖默认计算
 * @param {string} options.outputPath - 输出视频路径
 * @returns {string} FFmpeg命令
 */
function generateMultiVideoPageFlipCommand(videoPaths, options = {}) {
  // 设置默认值
  const {
    transitionDuration = 1,
    totalDuration,
    outputPath
  } = options;

  if (!videoPaths || videoPaths.length === 0) {
    throw new Error('至少需要一个视频文件');
  }

  if (!outputPath) {
    throw new Error('必须指定输出路径');
  }

  // 构建输入参数
  const inputParams = videoPaths.map((path, index) => `-i "${path}"`).join(" ");
  
  // 如果只有一个视频，直接处理
  if (videoPaths.length === 1) {
    const finalDuration = totalDuration || 5; // 默认5秒
    // 对于视频文件，我们不需要trim，而是设置输出时长
    return `${FFMPEG_V2_PATH} -y ${inputParams} -analyzeduration 5000000 -probesize 5000000 -t ${finalDuration} -c:v mpeg4 -q:v 5 -pix_fmt yuv420p "${outputPath}"`;
  }

  // 为每个输入创建处理链
  let filterChain = [];
  
  // 处理每个视频，不改变尺寸
  for (let i = 0; i < videoPaths.length; i++) {
    filterChain.push(`[${i}:v]loop=-1:size=1:start=0,setpts=N/30/TB[v${i}]`);
  }

  // 创建转场效果链
  let prevVideoStream = "[v0]"; // 从第一个视频流开始
  let cumDuration = 0; // 累积时长

  // 对每一对视频应用翻页转场效果
  for (let i = 1; i < videoPaths.length; i++) {
    // 计算偏移量 - 这是转场开始的时间点
    const offset = cumDuration + 5 - transitionDuration; // 默认每个视频展示5秒
    
    // 使用gltransition过滤器创建翻页效果
    const outputVideoLabel = `[outv${i}]`;
    
    filterChain.push(`${prevVideoStream}[v${i}]gltransition=duration=${transitionDuration}:offset=${offset}:source='${transitionsPath}/InvertedPageCurl.glsl'${outputVideoLabel}`);
    
    prevVideoStream = outputVideoLabel;
    
    // 更新累积时长
    cumDuration += 5; // 默认每个视频展示5秒
  }

  // 添加最终格式化过滤器
  filterChain.push(`${prevVideoStream}format=yuv420p[vout]`);

  // 完整的过滤器链
  const finalFilterChain = filterChain.join(";");
  const finalFilter = `${finalFilterChain}`;

  // 计算总时长 - 如果没有指定总时长，则按默认方式计算
  const calculatedDuration = videoPaths.length * 5 - (videoPaths.length - 1) * transitionDuration;
  const finalDuration = totalDuration || calculatedDuration;

  return `${FFMPEG_V2_PATH} -y ${inputParams} -analyzeduration 5000000 -probesize 5000000 -filter_complex "${finalFilter}" -map "[vout]" -c:v mpeg4 -q:v 5 -pix_fmt yuv420p -t ${finalDuration} "${outputPath}"`;
}

module.exports = {
  generateMultiVideoPageFlipCommand,
  preprocessVideosWithTpad
};